using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("PowerTaskList")]
	public class PowerTaskList : MonoClass
	{
		[Attribute38("PowerTaskList.DamageInfo")]
		public class DamageInfo : MonoClass
		{
			public Entity m_entity => method_3<Entity>("m_entity");

			public int m_damage => method_2<int>("m_damage");

			public DamageInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DamageInfo(IntPtr address)
				: this(address, "DamageInfo")
			{
			}
		}

		[Attribute38("PowerTaskList.ZoneChangeCallbackData")]
		public class ZoneChangeCallbackData : MonoClass
		{
			public int m_startIndex => method_2<int>("m_startIndex");

			public int m_count => method_2<int>("m_count");

			public object m_taskListUserData => method_3<object>("m_taskListUserData");

			public ZoneChangeCallbackData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ZoneChangeCallbackData(IntPtr address)
				: this(address, "ZoneChangeCallbackData")
			{
			}
		}

		public int m_id => method_2<int>("m_id");

		public Network.HistBlockStart m_blockStart => method_3<Network.HistBlockStart>("m_blockStart");

		public Network.HistBlockEnd m_blockEnd => method_3<Network.HistBlockEnd>("m_blockEnd");

		public List<PowerTask> m_tasks => method_3<Class271<PowerTask>>("m_tasks")?.method_25();

		public ZoneChangeList m_zoneChangeList => method_3<ZoneChangeList>("m_zoneChangeList");

		public PowerTaskList m_previous => method_3<PowerTaskList>("m_previous");

		public PowerTaskList m_next => method_3<PowerTaskList>("m_next");

		public PowerTaskList m_parent => method_3<PowerTaskList>("m_parent");

		public bool m_attackDataBuilt => method_2<bool>("m_attackDataBuilt");

		public AttackInfo m_attackInfo => method_3<AttackInfo>("m_attackInfo");

		public AttackType m_attackType => method_2<AttackType>("m_attackType");

		public Entity m_attacker => method_3<Entity>("m_attacker");

		public Entity m_defender => method_3<Entity>("m_defender");

		public Entity m_proposedDefender => method_3<Entity>("m_proposedDefender");

		public bool m_willCompleteHistoryEntry => method_2<bool>("m_willCompleteHistoryEntry");

		public Entity m_ritualEntityClone => method_3<Entity>("m_ritualEntityClone");

		public PowerTaskList(IntPtr address, string className)
			: base(address, className)
		{
		}

		public PowerTaskList(IntPtr address)
			: this(address, "PowerTaskList")
		{
		}

		public int GetId()
		{
			return method_11<int>("GetId", Array.Empty<object>());
		}

		public void SetId(int id)
		{
			method_8("SetId", id);
		}

		public bool IsEmpty()
		{
			return method_11<bool>("IsEmpty", Array.Empty<object>());
		}

		public bool IsOrigin()
		{
			return method_11<bool>("IsOrigin", Array.Empty<object>());
		}

		public PowerTaskList GetOrigin()
		{
			return method_14<PowerTaskList>("GetOrigin", Array.Empty<object>());
		}

		public PowerTaskList GetPrevious()
		{
			return method_14<PowerTaskList>("GetPrevious", Array.Empty<object>());
		}

		public void SetPrevious(PowerTaskList taskList)
		{
			method_8("SetPrevious", taskList);
		}

		public PowerTaskList GetNext()
		{
			return method_14<PowerTaskList>("GetNext", Array.Empty<object>());
		}

		public PowerTaskList GetLast()
		{
			return method_14<PowerTaskList>("GetLast", Array.Empty<object>());
		}

		public Network.HistBlockStart GetBlockStart()
		{
			return method_14<Network.HistBlockStart>("GetBlockStart", Array.Empty<object>());
		}

		public void SetBlockStart(Network.HistBlockStart blockStart)
		{
			method_8("SetBlockStart", blockStart);
		}

		public Network.HistBlockEnd GetBlockEnd()
		{
			return method_14<Network.HistBlockEnd>("GetBlockEnd", Array.Empty<object>());
		}

		public void SetBlockEnd(Network.HistBlockEnd blockEnd)
		{
			method_8("SetBlockEnd", blockEnd);
		}

		public PowerTaskList GetParent()
		{
			return method_14<PowerTaskList>("GetParent", Array.Empty<object>());
		}

		public void SetParent(PowerTaskList parent)
		{
			method_8("SetParent", parent);
		}

		public bool IsBlock()
		{
			return method_11<bool>("IsBlock", Array.Empty<object>());
		}

		public bool IsStartOfBlock()
		{
			return method_11<bool>("IsStartOfBlock", Array.Empty<object>());
		}

		public bool IsEndOfBlock()
		{
			return method_11<bool>("IsEndOfBlock", Array.Empty<object>());
		}

		public bool DoesBlockHaveEndAction()
		{
			return method_11<bool>("DoesBlockHaveEndAction", Array.Empty<object>());
		}

		public bool IsBlockUnended()
		{
			return method_11<bool>("IsBlockUnended", Array.Empty<object>());
		}

		public bool IsEarlierInBlockThan(PowerTaskList taskList)
		{
			return method_11<bool>("IsEarlierInBlockThan", new object[1] { taskList });
		}

		public bool IsLaterInBlockThan(PowerTaskList taskList)
		{
			return method_11<bool>("IsLaterInBlockThan", new object[1] { taskList });
		}

		public bool IsInBlock(PowerTaskList taskList)
		{
			return method_11<bool>("IsInBlock", new object[1] { taskList });
		}

		public bool IsDescendantOfBlock(PowerTaskList taskList)
		{
			return method_11<bool>("IsDescendantOfBlock", new object[1] { taskList });
		}

		public List<PowerTask> GetTaskList()
		{
			return method_14<Class271<PowerTask>>("GetTaskList", Array.Empty<object>())?.method_25();
		}

		public bool HasTasks()
		{
			return method_11<bool>("HasTasks", Array.Empty<object>());
		}

		public PowerTask CreateTask(Network.PowerHistory netPower)
		{
			return method_14<PowerTask>("CreateTask", new object[1] { netPower });
		}

		public bool HasTasksOfType(Network.PowerType powType)
		{
			return method_11<bool>("HasTasksOfType", new object[1] { powType });
		}

		public Entity GetSourceEntity()
		{
			return method_14<Entity>("GetSourceEntity", Array.Empty<object>());
		}

		public string GetEffectCardId()
		{
			return method_13("GetEffectCardId");
		}

		public EntityDef GetEffectEntityDef()
		{
			return method_14<EntityDef>("GetEffectEntityDef", Array.Empty<object>());
		}

		public CardDef GetEffectCardDef()
		{
			return method_14<CardDef>("GetEffectCardDef", Array.Empty<object>());
		}

		public Entity GetTargetEntity()
		{
			return method_14<Entity>("GetTargetEntity", Array.Empty<object>());
		}

		public bool HasTargetEntity()
		{
			return method_11<bool>("HasTargetEntity", Array.Empty<object>());
		}

		public bool HasMetaDataTasks()
		{
			return method_11<bool>("HasMetaDataTasks", Array.Empty<object>());
		}

		public bool DoesBlockHaveMetaDataTasks()
		{
			return method_11<bool>("DoesBlockHaveMetaDataTasks", Array.Empty<object>());
		}

		public bool HasEffectTimingMetaData()
		{
			return method_11<bool>("HasEffectTimingMetaData", Array.Empty<object>());
		}

		public bool DoesBlockHaveEffectTimingMetaData()
		{
			return method_11<bool>("DoesBlockHaveEffectTimingMetaData", Array.Empty<object>());
		}

		public bool IsPlayBlock()
		{
			return method_11<bool>("IsPlayBlock", Array.Empty<object>());
		}

		public bool IsPowerBlock()
		{
			return method_11<bool>("IsPowerBlock", Array.Empty<object>());
		}

		public bool IsTriggerBlock()
		{
			return method_11<bool>("IsTriggerBlock", Array.Empty<object>());
		}

		public bool IsDeathBlock()
		{
			return method_11<bool>("IsDeathBlock", Array.Empty<object>());
		}

		public bool IsRitualBlock()
		{
			return method_11<bool>("IsRitualBlock", Array.Empty<object>());
		}

		public void DoTasks(int startIndex, int count)
		{
			method_9("DoTasks", new Class276.Enum20[2]
			{
				Class276.Enum20.I4,
				Class276.Enum20.I4
			}, startIndex, count);
		}

		public void DoAllTasks()
		{
			method_9("DoAllTasks", new Class276.Enum20[0]);
		}

		public void DoEarlyConcedeTasks()
		{
			method_8("DoEarlyConcedeTasks");
		}

		public bool IsComplete()
		{
			return method_11<bool>("IsComplete", Array.Empty<object>());
		}

		public bool AreTasksComplete()
		{
			return method_11<bool>("AreTasksComplete", Array.Empty<object>());
		}

		public int FindEarlierIncompleteTaskIndex(int taskIndex)
		{
			return method_11<int>("FindEarlierIncompleteTaskIndex", new object[1] { taskIndex });
		}

		public bool HasEarlierIncompleteTask(int taskIndex)
		{
			return method_11<bool>("HasEarlierIncompleteTask", new object[1] { taskIndex });
		}

		public bool HasZoneChanges()
		{
			return method_11<bool>("HasZoneChanges", Array.Empty<object>());
		}

		public bool AreZoneChangesComplete()
		{
			return method_11<bool>("AreZoneChangesComplete", Array.Empty<object>());
		}

		public AttackInfo GetAttackInfo()
		{
			return method_14<AttackInfo>("GetAttackInfo", Array.Empty<object>());
		}

		public AttackType GetAttackType()
		{
			return method_11<AttackType>("GetAttackType", Array.Empty<object>());
		}

		public Entity GetAttacker()
		{
			return method_14<Entity>("GetAttacker", Array.Empty<object>());
		}

		public Entity GetDefender()
		{
			return method_14<Entity>("GetDefender", Array.Empty<object>());
		}

		public Entity GetProposedDefender()
		{
			return method_14<Entity>("GetProposedDefender", Array.Empty<object>());
		}

		public bool HasGameOver()
		{
			return method_11<bool>("HasGameOver", Array.Empty<object>());
		}

		public bool HasFriendlyConcede()
		{
			return method_11<bool>("HasFriendlyConcede", Array.Empty<object>());
		}

		public DamageInfo GetDamageInfo(Entity entity)
		{
			return method_14<DamageInfo>("GetDamageInfo", new object[1] { entity });
		}

		public void SetWillCompleteHistoryEntry(bool set)
		{
			method_8("SetWillCompleteHistoryEntry", set);
		}

		public bool WillCompleteHistoryEntry()
		{
			return method_11<bool>("WillCompleteHistoryEntry", Array.Empty<object>());
		}

		public bool WillBlockCompleteHistoryEntry()
		{
			return method_11<bool>("WillBlockCompleteHistoryEntry", Array.Empty<object>());
		}

		public Entity GetRitualEntityClone()
		{
			return method_14<Entity>("GetRitualEntityClone", Array.Empty<object>());
		}

		public void SetRitualEntityClone(Entity ent)
		{
			method_8("SetRitualEntityClone", ent);
		}

		public bool WasThePlayedSpellCountered(Entity entity)
		{
			return method_11<bool>("WasThePlayedSpellCountered", new object[1] { entity });
		}

		public void CreateArtificialHistoryTilesFromMetadata()
		{
			method_8("CreateArtificialHistoryTilesFromMetadata");
		}

		public bool ShouldCreatePlayBlockHistoryTile()
		{
			return method_11<bool>("ShouldCreatePlayBlockHistoryTile", Array.Empty<object>());
		}

		public void DebugDump()
		{
			method_9("DebugDump", new Class276.Enum20[0]);
		}

		public void DebugDump(Logger logger)
		{
			method_9("DebugDump", new Class276.Enum20[1] { Class276.Enum20.Class }, logger);
		}

		public new string ToString()
		{
			return method_13("ToString");
		}

		public void OnZoneChangeComplete(ZoneChangeList changeList, object userData)
		{
			method_8("OnZoneChangeComplete", changeList, userData);
		}

		public void BuildAttackData()
		{
			method_8("BuildAttackData");
		}

		public AttackInfo BuildAttackInfo()
		{
			return method_14<AttackInfo>("BuildAttackInfo", Array.Empty<object>());
		}
	}
}
